package homework.homwork12;

import homework.day12.te.Product;

import java.util.*;

/**
 * @author success
 * @version 1.0
 * @description:本类用来演示:
 * @date 2019/8/1 0001
 */
public class TestProduct {
    public static void main(String[] args) {

        List<Product> list = new ArrayList<>();
        Product p1 = new Product("宝洁","洗手粉",18.5);
        Product p2 = new Product("联合利华","肥皂",4.5);
        Product p3 = new Product("宝洁","牙膏",32.5);
        Product p4 = new Product("宝洁","毛巾",14.5);
        Product p5 = new Product("洁利","洗面奶",26.0);
        Product p6 = new Product("好迪","洗发水",27.5);
        Product p7 = new Product("多芬","沐浴露",38.5);
        Product p8 = new Product("宝洁","洗洁精",3.4);

        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);
        list.add(p7);
        list.add(p8);

        method02(list);
    }

    /**
     * 利用的是内置的Entry对象来封装key - value
     *                              品牌名 - 总价
     * @param list
     */
    @SuppressWarnings("all")
    public static void method02(List<Product> list){
            //创建一个map集合,用来保存?
            //key代表的是品牌的名称
            //value是该品牌对应的所有的product对象.
            Map<String,List<Product>> map = new HashMap<>();

            //遍历list集合
            //目的 - 将品牌和各自的p对应起来.
            for(Product p:list){
                //获取品牌的名称
                String brand = p.getBrand();

                //判断map集合中是否包含key - 品牌名
                if(map.containsKey(brand)){
                    //根据key获取值
                    List<Product> oldProds = map.get(brand);
                    oldProds.add(p);
                }else{
                    //创建每个品牌的集合
                    List<Product> products = new ArrayList<>();
                    products.add(p);
                    map.put(brand,products);
                }
            }

           //创建一个map集合  - key - total
           Map<String,Double> vosMap = new HashMap<>();

            //map.forEach((k,v)->System.out.println(k+"->"+v));
            //统计每个品牌和它的总价
            Set<String> sets = map.keySet();
            Iterator<String> iter = sets.iterator();
            while(iter.hasNext()){
                String key = iter.next();

                //拿到这个品牌的集合对象
                List<Product> px = map.get(key);

                //定义一个总价 - 每个品牌的
                double total = 0.0D;

                //遍历集合
                for (Product p:px){
                    total+= p.getCost();
                }

                //重新认识一下实体类 - 特殊容器的"数组" - 数据在内存中的载体.
                //System.out.println(key+"->"+total);
                vosMap.put(key,total);
            }
            //创建一个集合,用来封装内置的Entry
            List<Map.Entry<String,Double>> sortList = new ArrayList<>();

            //采用map集合的第二种迭代方式
            Set<Map.Entry<String,Double>> entrys = vosMap.entrySet();
            Iterator<Map.Entry<String,Double>> iters = entrys.iterator();
            while(iters.hasNext()){
                Map.Entry<String,Double> entry = iters.next();

                sortList.add(entry);
            }

            Collections.sort(sortList, new Comparator<Map.Entry<String, Double>>() {
                @Override
                public int compare(Map.Entry<String, Double> o1, Map.Entry<String, Double> o2) {
                    if(o1.getValue()>o2.getValue())
                        return -1;
                    else if(o1.getValue()<o2.getValue())
                        return 1;
                    return 0;
                }
            });

            sortList.forEach(System.out::println);

        }


    /**
     * 思想 - 第三方实体类
     * 神似 - 1 1 2 1 2 4 2 1 1 2 4 5 ...
     *
     * 分析 - 统计 - 排序[数据处理]
     * 根据品牌来统计每个品牌的产品的总价.
     * @param list
     */
    @SuppressWarnings("all")
    private static void method01(List<Product> list) {
        //创建一个map集合,用来保存?
        //key代表的是品牌的名称
        //value是该品牌对应的所有的product对象.
        Map<String,List<Product>> map = new HashMap<>();

        //遍历list集合
        //目的 - 将品牌和各自的p对应起来.
        for(Product p:list){
            //获取品牌的名称
            String brand = p.getBrand();

            //判断map集合中是否包含key - 品牌名
            if(map.containsKey(brand)){
                //根据key获取值
                List<Product> oldProds = map.get(brand);
                oldProds.add(p);
            }else{
                //创建每个品牌的集合
                List<Product> products = new ArrayList<>();
                products.add(p);
                map.put(brand,products);
            }
        }

        //创建一个集合 - 为排序做准备的
        List<ProductVo> vos = new ArrayList<>();

        //map.forEach((k,v)->System.out.println(k+"->"+v));
        //统计每个品牌和它的总价
        Set<String> sets = map.keySet();
        Iterator<String> iter = sets.iterator();
        while(iter.hasNext()){
            String key = iter.next();

            //拿到这个品牌的集合对象
            List<Product> px = map.get(key);

            //定义一个总价 - 每个品牌的
            double total = 0.0D;

            //遍历集合
            for (Product p:px){
                total+= p.getCost();
            }

            //重新认识一下实体类 - 特殊容器的"数组" - 数据在内存中的载体.
            //System.out.println(key+"->"+total);

            //创建一个ProductVo对象
            ProductVo vo = new ProductVo(key,total);
            //添加到集合中
            vos.add(vo);
        }
        //利用集合的工具类进行排序
        Collections.sort(vos, new Comparator<ProductVo>() {
            @Override
            public int compare(ProductVo o1, ProductVo o2) {
                if(o1.getTotal()>o2.getTotal()){
                    return -1;
                }else if(o1.getTotal()<o2.getTotal()){
                    return 1;
                }
                return 0;
            }
        });

        //重新遍历vos
        vos.forEach(System.out::println);
    }
}
